const vscode = require('vscode');
const fs = require('fs-extra');
const path = require('path');
const configManager = require('./configManager');

/**
 * 模板创建模块
 */
class TemplateCreator {
    /**
     * 从模板创建文件或文件夹
     * @param {vscode.Uri} targetUri 目标位置URI
     * @returns {Promise<void>}
     */
    static async createFromTemplate(targetUri) {
        try {
            // 获取所有模板源配置
            const templateSources = configManager.getTemplateSourcesConfig();
            if (!templateSources || templateSources.length === 0) {
                throw new Error('未找到模板源配置，请先在设置中配置模板源');
            }

            // 选择模板源
            const selectedSource = await this.selectTemplateSource(templateSources);
            if (!selectedSource) {
                vscode.window.showInformationMessage('已取消模板创建操作');
                return false; // 用户取消了选择
            }

            // 根据模板源类型处理
            let result;
            if (selectedSource.type === 'local') {
                result = await this.handleLocalTemplate(selectedSource, targetUri);
            } else if (selectedSource.type === 'git') {
                result = await this.handleGitTemplate(selectedSource, targetUri);
            } else {
                throw new Error(`不支持的模板源类型: ${selectedSource.type}`);
            }
            
            // 只有当操作明确成功完成时才显示成功消息
            if (result === true) {
                vscode.window.showInformationMessage('文件创建成功！');
                return true;
            } else {
                // 如果没有明确返回true，则视为操作被取消
                return false;
            }
        } catch (error) {
            console.error('创建模板失败:', error);
            throw error;
        }
    }

    /**
     * 选择模板源
     * @param {Array} templateSources 模板源配置数组
     * @returns {Promise<Object>} 选择的模板源
     */
    static async selectTemplateSource(templateSources) {
        // 如果只有一个模板源，直接返回
        if (templateSources.length === 1) {
            return templateSources[0];
        }

        // 创建QuickPick选项
        const options = templateSources.map(source => ({
            label: source.name,
            description: source.type === 'local' ? source.path : source.address,
            source: source
        }));

        // 显示QuickPick
        const selected = await vscode.window.showQuickPick(options, {
            placeHolder: '选择模板源'
        });

        return selected ? selected.source : false;
    }

    /**
     * 处理本地模板
     * @param {Object} source 模板源配置
     * @param {vscode.Uri} targetUri 目标位置URI
     * @returns {Promise<void>}
     */
    static async handleLocalTemplate(source, targetUri) {
        try {
            const sourcePath = source.path;
            
            // 验证本地路径
            if (!configManager.validateLocalPath(sourcePath)) {
                throw new Error(`无效的本地模板路径: ${sourcePath}`);
            }

            // 获取模板内容
            const isDirectory = fs.statSync(sourcePath).isDirectory();
            
            if (isDirectory) {
                // 如果是目录，选择目录内容
                const templateContent = await this.selectTemplateContent(sourcePath);
                if (!templateContent) {
                    vscode.window.showInformationMessage('已取消模板创建操作');
                    return false; // 用户取消了选择
                }
                
                // 获取目标名称
                const targetName = await this.getTargetName(path.basename(templateContent));
                if (!targetName) {
                    vscode.window.showInformationMessage('已取消模板创建操作');
                    return false; // 用户取消了输入
                }
                
                // 创建目标路径
                const targetPath = path.join(targetUri.fsPath, targetName);
                
                // 复制模板到目标位置
                if (fs.statSync(templateContent).isDirectory()) {
                    await fs.copy(templateContent, targetPath);
                } else {
                    await fs.copy(templateContent, targetPath);
                }
            } else {
                // 如果是文件，直接复制
                const targetName = await this.getTargetName(path.basename(sourcePath));
                if (!targetName) {
                    vscode.window.showInformationMessage('已取消模板创建操作');
                    return false; // 用户取消了输入
                }
                
                const targetPath = path.join(targetUri.fsPath, targetName);
                await fs.copy(sourcePath, targetPath);
            }
            
            return true; // 操作成功完成
        } catch (error) {
            console.error('处理本地模板失败:', error);
            throw error;
        }
    }

    /**
     * 处理Git仓库模板
     * @param {Object} source 模板源配置
     * @param {vscode.Uri} targetUri 目标位置URI
     * @returns {Promise<void>}
     */
    static async handleGitTemplate(source, targetUri) {
        try {
            // 检查localPath是否存在，不存在则创建
            if (!fs.existsSync(source.localPath)) {
                await fs.mkdirp(source.localPath);
                console.log(`创建本地路径: ${source.localPath}`);
            }
            
            // 从Git URL中提取仓库名称
            const repoName = source.url.split('/').pop().replace('.git', '');
            
            // 构建完整的仓库本地路径（localPath + 仓库名称）
            const fullRepoPath = path.join(source.localPath, repoName);
            
            // 修改source对象中的localPath为完整路径，以便ensureGitRepository正确处理
            const gitConfig = {...source, localPath: fullRepoPath};
            
            // 确保Git仓库已克隆并更新
            await configManager.ensureGitRepository(gitConfig);
            
            // 构建模板路径（仓库路径 + 配置的子路径）
            let templatePath = fullRepoPath;
            
            // 如果配置了仓库内的子路径，则添加到路径中
            if (source.path) {
                templatePath = path.join(fullRepoPath, source.path.replace(/^\//,''));
            }
            
            // 验证路径是否存在
            if (!fs.existsSync(templatePath)) {
                const answer = await vscode.window.showErrorMessage(
                    `Git仓库中的路径不存在: ${templatePath}`,
                    '创建目录', '取消'
                );
                
                if (answer === '创建目录') {
                    await fs.mkdirp(templatePath);
                    console.log(`创建目录: ${templatePath}`);
                } else {
                    vscode.window.showInformationMessage('已取消模板创建操作');
                    return false; // 用户取消操作
                }
            }
            
            // 选择模板内容
            const templateContent = await this.selectTemplateContent(templatePath);
            if (!templateContent) {
                vscode.window.showInformationMessage('已取消模板创建操作');
                return false; // 用户取消了选择
            }
            
            // 获取目标名称
            const targetName = await this.getTargetName(path.basename(templateContent));
            if (!targetName) {
                vscode.window.showInformationMessage('已取消模板创建操作');
                return false; // 用户取消了输入
            }
            
            // 创建目标路径
            const targetPath = path.join(targetUri.fsPath, targetName);
            
            // 复制模板到目标位置
            if (fs.statSync(templateContent).isDirectory()) {
                await fs.copy(templateContent, targetPath);
            } else {
                await fs.copy(templateContent, targetPath);
            }
            
            return true; // 操作成功完成
        } catch (error) {
            console.error('处理Git仓库模板失败:', error);
            throw error;
        }
    }

    /**
     * 选择模板内容
     * @param {string} sourcePath 模板源路径
     * @returns {Promise<string>} 选择的模板内容路径
     */
    static async selectTemplateContent(sourcePath) {
        try {
            // 读取目录内容
            const items = await fs.readdir(sourcePath);
            
            // 创建QuickPick选项
            const options = [
                {
                    label: '$(folder) 选择整个文件夹',
                    description: '复制整个文件夹及其内容',
                    path: sourcePath
                },
                ...items.map(item => {
                    const itemPath = path.join(sourcePath, item);
                    const isDir = fs.statSync(itemPath).isDirectory();
                    return {
                        label: `${isDir ? '$(folder)' : '$(file)'} ${item}`,
                        description: isDir ? '文件夹' : '文件',
                        path: itemPath
                    };
                })
            ];
            
            // 显示QuickPick
            const selected = await vscode.window.showQuickPick(options, {
                placeHolder: '选择模板内容'
            });
            
            return selected ? selected.path : null;
        } catch (error) {
            console.error('选择模板内容失败:', error);
            throw error;
        }
    }



    /**
     * 获取目标名称
     * @param {string} defaultName 默认名称
     * @returns {Promise<string>} 目标名称
     */
    static async getTargetName(defaultName) {
        return await vscode.window.showInputBox({
            prompt: '输入目标名称',
            value: defaultName,
            validateInput: (value) => {
                if (!value) {
                    return '名称不能为空';
                }
                if (/[\\/:*?"<>|]/.test(value)) {
                    return '名称不能包含特殊字符: \\ / : * ? " < > |';
                }
                return null;
            }
        });
    }
}

module.exports = TemplateCreator;